//! # 配置管理模块
//! 
//! 本模块提供RustCloud框架的统一配置管理功能，支持多种配置源和灵活的配置组织。
//! 采用分层配置设计，支持配置继承、环境隔离和热更新。
//! 
//! ## 核心特性
//! 
//! - **统一配置**: 一个配置结构管理所有框架和组件配置
//! - **多格式支持**: 支持TOML、YAML、JSON等多种配置文件格式
//! - **环境隔离**: 支持不同环境（dev、test、prod）的配置分离
//! - **配置验证**: 提供配置参数的合法性验证
//! - **热更新**: 支持运行时配置的动态更新
//! 
//! ## 模块化架构
//! 
//! 配置模块采用模块化设计，包含以下子模块：
//! 
//! - [`service`] - 服务配置
//! - [`component`] - 组件配置
//! - [`network`] - 网络配置
//! - [`monitoring`] - 监控配置
//! - [`security`] - 安全配置
//! - [`performance`] - 性能配置
//! - [`traits`] - 配置接口定义

pub mod service;
pub mod component;
pub mod network;
pub mod monitoring;
pub mod security;
pub mod performance;
pub mod traits;

// 重新导出所有公共接口和类型
pub use service::*;
pub use component::*;
pub use network::*;
pub use monitoring::*;
pub use security::*;
pub use performance::*;
pub use traits::*;

/// RustCloud框架的统一配置
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct RustCloudConfig {
    /// 服务基本信息
    pub service: ServiceConfig,
    
    /// 组件配置
    pub components: ComponentConfig,
    
    /// 网络配置
    pub network: NetworkConfig,
    
    /// 监控配置
    pub monitoring: MonitoringConfig,
    
    /// 安全配置
    pub security: SecurityConfig,
    
    /// 性能配置
    pub performance: PerformanceConfig,
}

impl Default for RustCloudConfig {
    fn default() -> Self {
        Self {
            service: ServiceConfig::default(),
            components: ComponentConfig::default(),
            network: NetworkConfig::default(),
            monitoring: MonitoringConfig::default(),
            security: SecurityConfig::default(),
            performance: PerformanceConfig::default(),
        }
    }
}

impl RustCloudConfig {
    /// 从文件加载配置
    pub async fn from_file(path: &str) -> rustcloud_core::ServiceResult<Self> {
        let content = tokio::fs::read_to_string(path)
            .await
            .map_err(|e| rustcloud_core::ServiceError::ConfigurationError(format!("读取配置文件失败: {}", e)))?;
        
        let config: RustCloudConfig = if path.ends_with(".toml") {
            toml::from_str(&content)
        } else if path.ends_with(".yaml") || path.ends_with(".yml") {
            serde_yaml::from_str(&content)
        } else if path.ends_with(".json") {
            serde_json::from_str(&content)
        } else {
            // 默认尝试TOML格式
            toml::from_str(&content)
        }.map_err(|e| rustcloud_core::ServiceError::ConfigurationError(format!("解析配置文件失败: {}", e)))?;
        
        Ok(config)
    }
    
    /// 保存配置到文件
    pub async fn save_to_file(&self, path: &str) -> rustcloud_core::ServiceResult<()> {
        let content = if path.ends_with(".toml") {
            toml::to_string_pretty(self)
        } else if path.ends_with(".yaml") || path.ends_with(".yml") {
            serde_yaml::to_string(self)
        } else if path.ends_with(".json") {
            serde_json::to_string_pretty(self)
        } else {
            toml::to_string_pretty(self)
        }.map_err(|e| rustcloud_core::ServiceError::ConfigurationError(format!("序列化配置失败: {}", e)))?;
        
        tokio::fs::write(path, content)
            .await
            .map_err(|e| rustcloud_core::ServiceError::ConfigurationError(format!("写入配置文件失败: {}", e)))?;
        
        Ok(())
    }
    
    /// 从环境变量和命令行参数合并配置
    pub fn merge_from_env(&mut self) -> rustcloud_core::ServiceResult<()> {
        // 从环境变量读取配置
        if let Ok(service_name) = std::env::var("RUSTCLOUD_SERVICE_NAME") {
            self.service.name = service_name;
        }
        
        if let Ok(service_version) = std::env::var("RUSTCLOUD_SERVICE_VERSION") {
            self.service.version = service_version;
        }
        
        if let Ok(environment) = std::env::var("RUSTCLOUD_ENVIRONMENT") {
            self.service.environment = environment;
        }
        
        if let Ok(port) = std::env::var("RUSTCLOUD_PORT") {
            self.network.port = port.parse()
                .map_err(|e| rustcloud_core::ServiceError::ConfigurationError(format!("无效的端口号: {}", e)))?;
        }
        
        if let Ok(registry_endpoints) = std::env::var("RUSTCLOUD_REGISTRY_ENDPOINTS") {
            self.components.registry.endpoints = registry_endpoints
                .split(',')
                .map(|s| s.trim().to_string())
                .collect();
        }
        
        if let Ok(log_level) = std::env::var("RUSTCLOUD_LOG_LEVEL") {
            self.monitoring.logging.level = log_level;
        }
        
        Ok(())
    }
    
    /// 验证配置的有效性
    pub fn validate(&self) -> rustcloud_core::ServiceResult<()> {
        if self.service.name.is_empty() {
            return Err(rustcloud_core::ServiceError::ConfigurationError("服务名称不能为空".to_string()));
        }
        
        if self.network.port == 0 {
            return Err(rustcloud_core::ServiceError::ConfigurationError("服务端口不能为0".to_string()));
        }
        
        if self.components.registry.endpoints.is_empty() {
            return Err(rustcloud_core::ServiceError::ConfigurationError("注册中心地址不能为空".to_string()));
        }
        
        // 验证负载均衡策略
        let valid_strategies = ["round_robin", "random", "weighted_round_robin", "least_connections", "consistent_hash"];
        if !valid_strategies.contains(&self.components.load_balancer.strategy.as_str()) {
            return Err(rustcloud_core::ServiceError::ConfigurationError(
                format!("无效的负载均衡策略: {}", self.components.load_balancer.strategy)
            ));
        }
        
        // 验证日志级别
        let valid_log_levels = ["trace", "debug", "info", "warn", "error"];
        if !valid_log_levels.contains(&self.monitoring.logging.level.as_str()) {
            return Err(rustcloud_core::ServiceError::ConfigurationError(
                format!("无效的日志级别: {}", self.monitoring.logging.level)
            ));
        }
        
        Ok(())
    }
}